"""
用户设置服务模块

负责处理用户个性化设置的业务逻辑，包括：
1. 用户设置的CRUD操作
2. 默认模型配置管理
3. 标题生成设置管理
4. 设置验证和默认值处理

主要功能：
- 用户设置的创建、读取、更新、删除
- 默认设置初始化
- 设置验证和约束检查
- 与模型配置的关联管理

作者: LLM Chat System
版本: 1.0.0
"""

from typing import Optional, Dict, Any
from sqlalchemy.orm import Session
from sqlalchemy.exc import IntegrityError
from app.core.logging_config import get_logger

# 导入数据模型
from app.models.user_settings import UserSettings
from app.models.user import User
from app.models.model_config import ModelConfig

# 导入数据模式
from app.schemas.user_settings import (
    UserSettingsCreate, 
    UserSettingsUpdate, 
    UserSettingsResponse,
    UserSettingsWithModels
)


class UserSettingsService:
    """
    用户设置服务类
    
    提供用户设置相关的业务逻辑处理，包括设置的CRUD操作、
    默认值处理、验证等功能。
    """
    
    def __init__(self):
        """初始化用户设置服务"""
        self.logger = get_logger(__name__)
    
    def get_user_settings(self, db: Session, user_id: int) -> Optional[UserSettings]:
        """
        获取用户设置
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            UserSettings: 用户设置对象，如果不存在则返回None
        """
        try:
            settings = db.query(UserSettings).filter(UserSettings.user_id == user_id).first()
            if settings:
                self.logger.info(f"获取用户设置成功: user_id={user_id}")
            else:
                self.logger.info(f"用户设置不存在: user_id={user_id}")
            return settings
        except Exception as e:
            self.logger.error(f"获取用户设置失败: user_id={user_id}, error={str(e)}")
            raise
    
    def create_user_settings(self, db: Session, user_id: int, settings_data: UserSettingsCreate) -> UserSettings:
        """
        创建用户设置
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            settings_data: 设置数据
            
        Returns:
            UserSettings: 创建的用户设置对象
        """
        try:
            # 检查用户是否存在
            user = db.query(User).filter(User.id == user_id).first()
            if not user:
                raise ValueError(f"用户不存在: user_id={user_id}")
            
            # 检查是否已有设置记录
            existing_settings = db.query(UserSettings).filter(UserSettings.user_id == user_id).first()
            if existing_settings:
                raise ValueError(f"用户设置已存在: user_id={user_id}")
            
            # 验证模型ID（如果提供）
            if settings_data.default_model_id:
                self._validate_model_id(db, settings_data.default_model_id)
            
            if settings_data.title_generation_model_id:
                self._validate_model_id(db, settings_data.title_generation_model_id)
            
            # 创建设置记录
            settings = UserSettings(
                user_id=user_id,
                **settings_data.dict(exclude={'user_id'})
            )
            
            db.add(settings)
            db.commit()
            db.refresh(settings)
            
            self.logger.info(f"创建用户设置成功: user_id={user_id}, settings_id={settings.id}")
            return settings
            
        except Exception as e:
            db.rollback()
            self.logger.error(f"创建用户设置失败: user_id={user_id}, error={str(e)}")
            raise
    
    def update_user_settings(self, db: Session, user_id: int, settings_data: UserSettingsUpdate) -> Optional[UserSettings]:
        """
        更新用户设置
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            settings_data: 更新的设置数据
            
        Returns:
            UserSettings: 更新后的用户设置对象
        """
        try:
            settings = db.query(UserSettings).filter(UserSettings.user_id == user_id).first()
            if not settings:
                self.logger.warning(f"用户设置不存在，将创建新设置: user_id={user_id}")
                # 如果设置不存在，创建默认设置
                default_settings = UserSettingsCreate(
                    user_id=user_id,
                    **settings_data.dict(exclude_none=True)
                )
                return self.create_user_settings(db, user_id, default_settings)
            
            # 验证模型ID（如果提供）
            if settings_data.default_model_id is not None:
                self._validate_model_id(db, settings_data.default_model_id)
            
            if settings_data.title_generation_model_id is not None:
                self._validate_model_id(db, settings_data.title_generation_model_id)
            
            # 更新设置
            update_data = settings_data.dict(exclude_none=True)
            for field, value in update_data.items():
                setattr(settings, field, value)
            
            db.commit()
            db.refresh(settings)
            
            self.logger.info(f"更新用户设置成功: user_id={user_id}")
            return settings
            
        except Exception as e:
            db.rollback()
            self.logger.error(f"更新用户设置失败: user_id={user_id}, error={str(e)}")
            raise
    
    def get_or_create_user_settings(self, db: Session, user_id: int) -> UserSettings:
        """
        获取或创建用户设置
        
        如果用户设置不存在，则创建默认设置。
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            UserSettings: 用户设置对象
        """
        try:
            settings = self.get_user_settings(db, user_id)
            if not settings:
                # 创建默认设置
                default_settings = UserSettingsCreate(
                    user_id=user_id,
                    auto_title_generation=True,
                    title_generation_threshold=3,
                    theme="light",
                    language="zh-CN",
                    font_size=14,
                    auto_save=True,
                    max_conversations=50,
                    enable_chain_of_thought=False
                )
                settings = self.create_user_settings(db, user_id, default_settings)
                self.logger.info(f"创建默认用户设置: user_id={user_id}")
            
            return settings
            
        except Exception as e:
            self.logger.error(f"获取或创建用户设置失败: user_id={user_id}, error={str(e)}")
            raise
    
    def get_user_settings_with_models(self, db: Session, user_id: int) -> Optional[UserSettingsWithModels]:
        """
        获取包含模型信息的用户设置
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            UserSettingsWithModels: 包含模型信息的用户设置
        """
        try:
            settings = self.get_user_settings(db, user_id)
            if not settings:
                return None
            
            # 获取模型名称
            default_model_name = None
            title_generation_model_name = None
            
            if settings.default_model_id:
                default_model = db.query(ModelConfig).filter(ModelConfig.id == settings.default_model_id).first()
                if default_model:
                    default_model_name = default_model.name
            
            if settings.title_generation_model_id:
                title_model = db.query(ModelConfig).filter(ModelConfig.id == settings.title_generation_model_id).first()
                if title_model:
                    title_generation_model_name = title_model.name
            
            # 构建响应数据，安全地处理可能不存在的字段
            settings_dict = {
                **settings.__dict__,
                'default_model_name': default_model_name,
                'title_generation_model_name': title_generation_model_name,
                'enable_chain_of_thought': getattr(settings, 'enable_chain_of_thought', False)
            }
            
            return UserSettingsWithModels(**settings_dict)
            
        except Exception as e:
            self.logger.error(f"获取用户设置和模型信息失败: user_id={user_id}, error={str(e)}")
            raise
    
    def _validate_model_id(self, db: Session, model_id: int) -> bool:
        """
        验证模型ID是否有效
        
        Args:
            db: 数据库会话
            model_id: 模型ID
            
        Returns:
            bool: 模型ID是否有效
            
        Raises:
            ValueError: 模型ID无效时抛出
        """
        model = db.query(ModelConfig).filter(
            ModelConfig.id == model_id,
            ModelConfig.is_active == True
        ).first()
        
        if not model:
            raise ValueError(f"模型不存在或未激活: model_id={model_id}")
        
        return True
    
    def delete_user_settings(self, db: Session, user_id: int) -> bool:
        """
        删除用户设置
        
        Args:
            db: 数据库会话
            user_id: 用户ID
            
        Returns:
            bool: 删除是否成功
        """
        try:
            settings = db.query(UserSettings).filter(UserSettings.user_id == user_id).first()
            if not settings:
                self.logger.warning(f"用户设置不存在: user_id={user_id}")
                return False
            
            db.delete(settings)
            db.commit()
            
            self.logger.info(f"删除用户设置成功: user_id={user_id}")
            return True
            
        except Exception as e:
            db.rollback()
            self.logger.error(f"删除用户设置失败: user_id={user_id}, error={str(e)}")
            raise
